package com.yang;

import java.io.BufferedReader;
import java.io.*;
import java.io.InputStreamReader;
import java.util.*;

public class Main {
    public static void main(String[] args) throws IOException {
        /*近日公司举行新游庆典活动，临时收到通知：老板希望会场拱门气球的颜色是对称，或可以最多戳爆一个气球使拱门气球颜色对称。请写程序判断现有拱门气球是否仍满足会场需要。
输入：拱门气球顺序的字符串，输出：true或false。
例如：（气球颜色用小写字母代替）
（1）输入：aba       输出：true
（2）输入：acea      输出：true //戳爆c或e
（3）输入：acfea     输出：false
注意：不可用二重循环暴力破解*/
        BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
        char[] str = in.readLine().toCharArray();

        int left = 0;
        int right = str.length - 1;
        int change = 1;
        boolean result = true;
        while (left < right){
            if(str[left] != str[right]){
                change--;
            }
            right --;
            left ++;
        }
        if(change < 0){
            result =  false;
        }
        System.out.println(result);
/*
        输入有两行，第一行n
        第二行是n个字符串，字符串之间用空格隔开
        输出一行排序后的字符串，空格隔开，无结尾空格

        BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
        int len = Integer.parseInt(in.readLine());
        String[] str = in.readLine().split(" ");
        Arrays.sort(str);

        PrintWriter out = new PrintWriter(new BufferedWriter(new OutputStreamWriter(System.out)));
        for(int i = 0; i < len; i ++){
            out.print(str[i]);
            out.print(" ");
        }
        out.close();
* */


/*
        输入数据有多组, 每行表示一组输入数据。
        每行不定有n个整数，空格隔开。(1 <= n <= 100)。

        BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
        String len = null;
        while((len = in.readLine()) != null){
            int i = 0;
            String[] str =  len.split(" ");
            int result = 0;
            int strLen = str.length;
            while(i < strLen){
                result += Integer.parseInt(str[i]);
                i++;
            }
            System.out.println(result);
        }*/

/*      不输入有多少组 自行判定
        输入数据有多组, 每行表示一组输入数据。
        每行的第一个整数为整数的个数n(1 <= n <= 100)。
        接下来n个正整数, 即需要求和的每个正整数。
        BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
        String s = null;
        while((s = in.readLine()) != null){

            String[] split = s.split(" ");
            int n = Integer.parseInt(split[0]);
            int result = 0;
            for(int j = 1; j <= n; j ++){
                result += Integer.parseInt(split[j]);
            }
            System.out.println(result);
        }
**/
/*
        输入的第一行包括一个正整数t(1 <= t <= 100), 表示数据组数。
        接下来t行, 每行一组数据。
        每行的第一个整数为整数的个数n(1 <= n <= 100)。
        接下来n个正整数, 即需要求和的每个正整数。

        BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
        int groupNums = Integer.parseInt(in.readLine());
        for(int i = 0; i < groupNums; i++){
            String s = in.readLine();
            String[] split = s.split(" ");
            int n = Integer.parseInt(split[0]);
            if(n == 0) break;
            int result = 0;
            for(int j = 1; j <= n; j ++){
                result += Integer.parseInt(split[j]);
            }
            System.out.println(result);
        }
*/

/*
每组数据一行,每行的第一个整数为 该行要相加的个数, n为0的时候结束输入。
接下来n个正整数,即需要求和的每个正整数。
        while( (s=in.readLine()) != null){
            String[] split = s.split(" ");
            int n = Integer.parseInt(split[0]);
            if(n == 0) break;
            int result = 0;
            for(int i = 1; i <= n; i ++){
                result += Integer.parseInt(split[i]);
            }
            System.out.println(result);
        }*/

/*   Test3
BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
        String s = null;
        while( (s=in.readLine()) != null){
            String[] split = s.split(" ");
            int a = Integer.parseInt(split[0]);
            int b = Integer.parseInt(split[1]);
            if(a == 0 && b == 0){
                break;
            }
            System.out.println(a + b);
        }*/

/*   Test2     BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
        int n =Integer.parseInt(in.readLine());
        for(int i = 0; i < n; i ++){
            String[] line = in.readLine().split(" ");
            int a = Integer.parseInt(line[0]);
            int b = Integer.parseInt(line[1]);
            System.out.println(a + b);
        }*/

/*  Test1      Scanner in = new Scanner(System.in);

        // 程序一直从键盘获取输入
        while(in.hasNext()){
            // 获取一个int类型的数
            int  a = in.nextInt();
            int b = in.nextInt();
            System.out.println(a + b);*/

       /* // 创建输入流
        BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
        // 输入一行
        String line = in.readLine();
        // 按空格分割  Integer.parseInt()可以转换
        String[] split = line.split(" ");
        for (String s : split) {
            System.out.println(s.getClass().toString());
            System.out.println();
            System.out.println(s);*/
    }
}

class testInputOutput{

}













/*美团有n件衣服，每件衣服下面有一个机器人，每个机器人启动需要消耗Pi的电量，收一件衣服需要ti的时间
每个机器人启动后将一直往右收衣服，直到右边的衣服正在被收或者以及收过了。
美团手上有电量b，打算在0时刻同时启动手上电量总共可启动的机器人，请问最佳选择下收衣服的最短时间（收不完衣服则输出-1）

输入：
3 5   //衣服数量n以及总电量b
1 2 3//
7 5 3 //对应机器人收衣服消耗的时间

输出：10
解释：收不完衣服的只有一种情况：连第一台机器人的电量都不够启动，则输出-1
    机器人只会向右收衣服，所以第一台必须启动
    如果启动第一台和第二台，电量消耗1 + 2 =3  < 5收衣服时间为max（7，5*2） = 10；
    如果启动第一台和第三台，电量消耗1 + 3 =4  < 5收衣服时间为max（7*2，5） = 14；
最佳方案对应的最短时间为10；*/

/*List<Integer> path = new ArrayList<>();

        testForTest testForTest = new testForTest();
        // 总电力
        int elTal = 9;
        // 衣服数量
//        int nums = 4;
        // 对应机器人收衣服消耗的时间
        int nums[] = {1 ,6 ,8 ,2, 4, 3, 5};

       // 启动时必然启动机器人1 所以初始化时认为第一件衣服已经启动机器人1收走了
       // 机器人1收走衣服1
       path.add(time[0]);
       // 回溯函数计算 收衣服时间
       //elTal总电量  nums衣服数量  time[]对应消耗时间  curNums当前衣服 curcel当前启动新机器人对应消耗电力,  times目前收衣服时间 curRobot表示使用的机器人
       testForTest.backtracking(elTal-1, nums, time, 1, 2, time[0], 0, path);
       System.out.println("最短时间:" + Collections.min(testForTest.result));
       for (int i = 0; i < testForTest.result.size(); i++) {
           System.out.println("可能的收衣服时间：" + testForTest.result.get(i));
       }*/

class testForTest {
    // 定义一个全局变量记录可能存在的结果
    List<Integer> result = new ArrayList<>();
    //elTal总电量  nums衣服数量 对应消耗电力也是当前衣服 time[]对应消耗时间  curNums当前衣服，  times目前收衣服时间 curRobot表示使用的机器人
    public void backtracking(int elTal, int nums, int time[], int curNums, int curel, int times, int curRobot, List<Integer> path) {
        // 衣服收完后记录消耗时间并结束递归
        if(curNums >= nums){
            // 收衣服时间取使用的机器人中消耗时间最多的
            result.add(Collections.max(path));
            return;
        }

        // 收一件衣服 记录当前机器人已消耗时间
        times += time[curRobot];
        // 当前衣服++
        curNums ++;
        // 若启动机器人消耗电力++
        curel ++;

        // 回溯 对应不同的情况 电量对应减少或不变 当前衣服(必然改变无需回溯) 当前消耗电力必然改变 当前使用机器人可能变可能不变
        // 记录当前机器人已消耗时间
        path.add(times);
        // 不启动新的机器人
        backtracking(elTal, nums, time, curNums, curel, times, curRobot, path);
        path.remove(path.size() - 1);

        // 启动新的机器人 更新机器人消耗时间(收衣服时间取使用的机器人中消耗时间最多的)
        if(elTal >= curel){
            times = time[curRobot + 1];
            path.add(times);
            backtracking(elTal - curel, nums, time, curNums, curel, times, curRobot + 1, path);
            path.remove(path.size() - 1);
        }

        return ;
    }
}


